Also noch einmal, das Kapitel ist überschrieben, der Lambda-Kalkül.

Ich hatte irgendwann mal eine Predigt drin, die es ins Skript geschafft hat.

Mittlerweile habe ich sie seit mehreren Semestern wieder gelöscht und kann sie insofern mündlich

halten, ohne dass es eine Wiederholung ist.

Also der Lambda-Kalkül, der jetzt folgt, ist eine der großen Erfindungen der Menschheit

auf einem Rang mit dem Otto-Motor und der Currywurst waren damals meine Beispiele.

Das mit dem Otto-Motor muss ich mir jetzt neu ausdenken, denn es sieht so aus, als

würde der Lambda-Kalkül länger überleben als der Otto-Motor.

Es handelt sich um eine natürliche Fortsetzung des Kapitels über Thermersetzungssysteme,

in dem der Lambda-Kalkül eigentlich im Wesentlichen eine Programmiersprache ist, die genau über

Thermersetzung funktioniert.

Mit anderen Worten, er ist einfach das Urmodell der Funktionalen Programmiersprache.

Also, ich halte mir das mal fest.

Also, wie gesagt, die Idee des Lambda-Kalküls ist im Wesentlichen Funktionales Programmieren.

Eine der Ideen, überhaupt der Hauptideen des Funktionalen Programmierens ist ja die

Idee der höheren Funktion.

Die höhere Funktion alleine macht den Lambda-Kalkül noch nicht aus, aber zumindest mal muss

man den Begriff der höheren Funktion verstanden haben, um den Lambda-Kalkül zu verstehen.

Ja, Erkenntnis von Funktionaler Programmierung war ja, wenn ich mich recht im Sinne hier

erfreulich weit verbreitet, das heißt, ich kann mich mit den Beispielen kurz halten.

Hier haben wir eine höhere Funktion, twice, die nimmt als Argument eine Funktion und gibt

mir zurück eine Funktion, die genau zweimal hintereinander Ausführungen von f darstellt.

Das heißt, die kann ich sehr schnell definieren.

Twice f von x ist einfach f von f von x.

Sie sehen schon hier, dass ich Heskel-Notationen verwende, sprich bei der Funktionen-Anwendung,

die Klammern ums Argument mir spare, bringt mit sich, dass man ab und zu andere Klammern

setzen muss.

Die Konventionen erläuter ich gleich noch in Detail.

Und dann vielleicht ein Beispiel, was nicht ganz so toll ist, die Funktion mapf, die Funktion

mapf nimmt sich also eine Funktion f und wandelt sie um in eine Funktion über Listen.

Das heißt, wenn ich die Rekursiv definieren will, habe ich die üblichen zwei Fälle, die

sehen aus, also wenn sie überhaupt irgendein funktionales Programm jemals gesehen haben,

dann sich ja auch gesehen haben.

Also das wäre einmal die Leere-Liste, gut mapf angewendet auf die Leere-Liste ist die

Leere-Liste und mapf angewendet auf eine zusammengesetzte Liste, klarerweise hier vielleicht Klammern,

mit Kopf x und Rest l, das ist einmal f angewendet auf den Kopf und dann Rekursiv diese Funktion

mapf angewendet auf den Rest.

Das sind jetzt zu viele Klammern, so viele Klammern muss man am Ende nicht setzen, aber

ungefähr so sieht es aus.

Also die Message ist, man will oft programmieren mit Funktionen, deren Argumente zumindest

intendiert wieder Funktionen sind und die womöglich auch Funktionen als Ergebnis ausspucken,

das ist das, was hier gemeint ist mit höheren Funktionen.

Das ist das, was wir hier sehen, das ist die Leere-Liste, das ist die Leere-Liste,

das ist die Leere-Liste, das ist die Leere-Liste, das ist die Leere-Liste, das ist die Leere-Liste.

So, den Lambda-Kalkül gibt es in verschiedenen Spielarten, die ursprüngliche Version und

die wir auch jetzt als erstes kennenlernen werden, ist der ungetypte Lambda-Kalkül und

der ist eben besser bekannt unter dem Namen Lisp, also die funktionale Programmiersprache

Lisp, die man eben aus der KI kennt, die klassische KI-Sprache, in der Zeit lang hat man Chips

gebaut, die nativ Lisp gesprochen haben.

Das ist im Wesentlichen eine Implementierung des ungetypten Lambda-Kalküls und wer kann